מערכות הפעלה מימוש זמן תהליכים, מימוש סמפור

Size: px

Start display at page:

Download "מערכות הפעלה מימוש זמן תהליכים, מימוש סמפור"

Nicholas King
6 years ago
Views:

1 מערכות הפעלה מימוש זמן תהליכים, מימוש סמפור תרגול 4

סביבת ריצה - אוגרים AX (accumulator), BX (base), CX (counter), DX (data) SI (source), DI (destination) SS (Stack) CS (Code) DS (Data) ES (Extra Data) SP (Stack pointer) IP (Instruction pointer) BP

2 סביבת ריצה - אוגרים AX (accumulator), BX (base), CX (counter), DX (data) SI (source), DI (destination) SS (Stack) CS (Code) DS (Data) ES (Extra Data) SP (Stack pointer) IP (Instruction pointer) BP (Base pointer) Flags רגיסטרים לשימוש כללי, איתם ניתן לבצע פעולות אריתמטיות ואחרות רגיסטרי אינדקס רגיסטרי סגמנט: שומרים ערכי סגמנטים של מקומות מיוחדים בזכרון מצביע על ראש המחסנית מצביע לפקודה הבאה בקוד התכנית מצביע על פרמטרים של הפונקציה הנקראת דגלים מערכות הפעלה - תרגול 2 2

3 סביבת ריצה אוגר FLAGS כולל את ביט אישור הפסיקות וכן ביטי Condition code הביטים שבשימוש על ידי XINU הם: 9 IF 6 ZF 0 CF Сarry (Zero Flag) ZF : מציין האם הערך האחרון שחושב הינו 0 )Carry Flag( CF : מציין האם בעת חישוב הערך האחרון נוצר אל מעבר לביט העליון של המילה )כאשר יש גלישה( : )Interrupt Flag( IF כשכבוי: פסיקות )חומרה בלבד( לא מאופשרת כשדלוק: פסיקות מאופשרות 3

4 סביבת ריצה התוכנה ב- XINU נחלקת לשני סגמנטים: )CS סגמנט קוד )אוגר סגמנט נתונים ומחסנית DS( - נתונים, - SS מחסנית( סגמנט הקוד )CS( כולל את הקוד של כל האפליקציה סגמנט הנתונים )DS( כולל את כל הנתונים הסטטיים בזיכרון, את המחסניות של כל התהליכים ואת שטח הזיכרון המיועד להקצאות זיכרון דינמיות 4

5 סביבת ריצה נשים לב ב- XINU כל התהליכים משתפים את: אותו קוד אותם נתונים סטטיים )משתנים גלובליים( אותו אזור להקצאה דינמית )כך ששימוש לא נכון יכול לדרוס זכרון שהוקצה ע"י תהליכים אחרים( אולם, לכל תהליך יש מחסנית נפרדת השייכת לו בלבד 5

6 סביבת ריצה - קריאה לפונקציה קריאה לפונקציה מתבצעת בכמה שלבים: באחריות הפונקציה הקוראת לשמור את ערכי האוגרים DX,CX,BX,AX במידה שידרשו לאחר החזרה הפונקציה הקוראת דוחפת את הפרמטרים על המחסנית )בסדר הפוך( הפונקציה הקוראת מבצעת פקודת המכונה לקריאה לפונקציה )שומרת כתובת החזרה על המחסנית( 6

7 סביבת ריצה - קריאה לפונקציה בהמשך: באחריות הפונקציה הנקראת לשמור את ערכי האוגרים DI,SI,BP )ואת Flags אם מבצעים )CLI,STI ולהקצות על המחסנית מקום למשתניה הלוקליים ערך הפונקציה מוחזר ברגיסטר AX אחרי החזרה, הפונקציה הקוראת אחראית להוציא את הפרמטרים מהמחסנית 7

8 סביבת ריצה המחסנית בתוך הקריאה... פרמטר 3 פרמטר 2 פרמטר 1 כתובת חזרה BP באחריות הפונקציה הקוראת sp לפני הקריאה לפני ביצוע call לאחר ביצוע call )תחילת ביצוע הנקראת( bp sp בזמן ביצוע הפונקציה הנקראת משתנים מקומיים SI DI... באחריות הפונקציה הנקראת 8

9 סביבת ריצה - קריאה לפונקציה אין צורך לשמור רגיסטרים בהם הפונקציה הקוראת לא משתמשת סדר דחיפת הפרמטרים הוא הפוך: הפרמטר הראשון הוא הקרוב ביותר לכתובת החזרה )4 + )BP כתובת חזרה נלקחת מ- CS:IP. בעת הקריאה IP כבר מצביע על הפקודה שאחרי הקריאה לפונקציה, ולכן זוהי כתובת החזרה ממנה 9

10 סביבת ריצה - קריאה לפונקציה BP נשמר על המחסנית לפני עדכונו. בכך מבטיחים שכל ערכי BP מהווים מעין רשימה מקושרת כך שכשיוצאים מפונקציה ניתן לשחזר את הערך הקודם משתנים לוקליים "מוקצים" מתוך המחסנית )פשוט על ידי קידום.)SP בכך מבטיחים שכאשר יוצאים מהפונקציה כל המשתנים הלוקליים משתחררים באופן אוטומטי בדרך כלל AX מספיק כדי להחזיר את ערך החזרה מהפונקציה. אם יש צורך להחזיר מצביע מפורש יוחזר הערך ב- DX:AX )Seg:Off( 10

11 מנגנון החלפת התהליכים העובדה שהמעבד משרת תהליך מסויים נובעת בעיקר מכך שאוגרי המעבד מכילים את הערכים "שלו" ראינו שזה קובע את הפקודות הבאות לביצוע, המחסנית הנוכחית, ערכי האוגרים ההקשר החלפת התהליכים היא פעולת החלפת הקשר switch( )context שמירת ההקשר של תהליך יוצא וטעינת ההקשר של תהליך נכנס מערכות הפעלה - תרגול 2 11

12 מנגנון החלפת התהליכים בנוסף להחלפת ההקשר להחלפת התהליכים שתי מחויבויות נוספות: מימוש מדיניות החלפת התהליכים עדכון מבנה נתונים גלובלי של XINU 12

13 החלפת הקשר בזמן החלפת הקשר של התהליך הנוכחי יש לשמור את ההקשר שלו ולטעון למעבד את ההקשר של התהליך המחליף ההקשר כולל: ערכי אוגרים Flags ערך הכתובת הבאה לביצוע המחסנית של התהליך ההקשר נשמר על גבי המחסנית של התהליך מצביע המחסנית נשמר בטבלת התהליכים 13

14 החלפת הקשר בהחלפת ההקשר יש גם לעדכן משתנים נוספים המציינים את מצבי התהליכים: currpid משתנה המציין את התהליך הנוכחי מצבי התהליכים בטבלת התהליכים )getlast/insert( READY עדכון תור ב- XINU הזימון והחלפת ההקשר נעשות ע"י פונקציות resched ו- ctxsw )במידה ויש החלפה בפועל( 14

15 החלפת הקשר - resched שגרת resched מרכזת את כל הפעולות הדרושות להחלפת הקשר קריאה לשגרה היא רק בדיקה האם צריך לבצע החלפת תהליך יוזמי הקריאה ל- resched : תהליך עצמו מערכת הפעלה 15

16 קריאה ל- resched ביוזמת התהליך ויתור של תהליך על המעבד המתנה להודעה/סמפור, השעייה, שינה, סוף התהליך תהליך דואג לשנות את מצבו לפני קריאה ל- resched כך גם resched מזהה שמדובר על ויתור במצב של ויתור התהליך תמיד יוצא מהמעבד ונשאר במצב שבחר לעצמו 16

17 קריאה ל- resched ביוזמת מ"ה הקריאה מתבצעת למרות שהתהליך הנוכחי מעוניין להמשיך לרוץ זה קורה כי: הקצאת הזמן של התהליך נגמרה קיים תהליך עם עדיפות יותר גבוהה שמוכן להכנם למעבד התהליך מגיע לשגרה במצב PRCURR כאן לא בהכרח תתבצע החלפת התהליכים )לפי מדיניות ההחלפה( אם בכל זאת ההחלפה מתבצעת התהליך עובר למצב של ונכנס לתור ה- READY PRREADY 17

18 טבלת תהליכים - proc.h #define NPROC 30 /* process state constants */ #define PRCURR #define PRFREE #define PRREADY #define PRRECV #define PRSLEEP #define PRSUSP #define PRWAIT ' 01\ ' ' 02\ ' ' 03\ ' ' 04\ ' ' 05\ ' ' 06\ ' ' 07\ ' // process is currently running // process slot is free // process is on ready queue // process waiting for message // process is sleeping // process is suspended // process is on semaphore queue 18

19 טבלת תהליכים - proc.h /* process table entry */ struct pentry { char pstate; /* process state: PRCURR, etc. */ int pprio; /* process priority */ int psem; /* semaphore if process waiting */ int pmsg; /* message sent to this process */ int phasmsg; /* nonzero iff pmsg is valid */ char *pregs; /* saved environment */ char *pbase; /* base of run time stack */ word plen; /* stack length in bytes */ char pname[pnmlen+1]; /* process name */ int pargs; /* initial number of arguments */ int (*paddr)(); /* initial code address */ }; 19

20 טבלת תהליכים - proc.h #define NULLPROC 0 /* id of the null process; it */ /* is always eligible to run */ extern struct pentry proctab[]; extern int numproc; /* currently active processes */ extern int nextproc; /* search point for free slot */ extern int currpid; /* currently executing process */ מערכות הפעלה - תרגול 2 20

21 resched.c - מימוש של resched int { resched() register struct pentry *optr; /* pointer to old process entry */ register struct pentry *nptr; /* pointer to new process entry */ optr = &proctab[currpid]; if ( optr->pstate == PRCURR ) // Initiator operating system { /* no switch needed if current prio. higher than next */ /* or if rescheduling is disabled ( pcxflag == 0 ) */ if ( sys_pcxget() == 0 lastkey(rdytail) < optr->pprio ( (lastkey(rdytail) == optr->pprio) && (preempt > 0) ) ) return; /* force context switch */ optr->pstate = PRREADY; insert(currpid,rdyhead,optr->pprio); } /* if */ else if ( sys_pcxget() == 0 ) // Resched is forbidden panic! { 21

22 resched.c - מימוש של resched } /* if */ else if ( sys_pcxget() == 0 ) // Resched is forbidden panic! { kprintf("pid=%d state=%d name=%s", currpid,optr->pstate,optr->pname); panic("reschedule impossible in this state"); } /* else if */ /* remove highest priority process at end of ready list */ nptr = &proctab[ (currpid = getlast(rdytail)) ]; nptr->pstate = PRCURR; /* mark it currently running */ preempt = QUANTUM; /* reset preemption counter */ ctxsw(&optr->pregs,&nptr->pregs); } /* The OLD process returns here when resumed. */ return; 22

23 מימוש של ctxsw ההנחה היא שכל תהליך שאינו רץ כרגע נמצא באמצע הקריאה ל- ctxsw פעולות של ctxsw החלפת ערך האוגר SP של התהליך היוצא בזה של התהליך הנכנס הפעלת מחסנית של התהליך הנכנס => מעבר לתהליך הנכנס ערך הSP נשמר בטבלת התהליכים שמירת אוגרים נוספים SI( )DI, במחסנית 23

24 ctxsw.asm ctxsw הקשר א' הקשר ב' ; void ctxsw(opp,npp) ; char *opp, *npp; ; Stack contents upon entry to ctxsw: ; SP+4 => address of new context stack save area ; SP+2 => address of old context stack save area ; SP => return address _ctxsw proc near _ctxsw push bp mov bp,sp ; frame pointer pushf ; flags save interrupt condition cli ; disable interrupts just to be sure push si push di ; preserve registers mov bx,[bp+4] ; old stack save address mov [bx],sp mov bx,[bp+6] ; new stack save address mov sp,[bx] pop di pop si popf ; restore interrupt state pop bp ret endp 24

25 ו) שימו לב! כאשר תהליך א' קורא ל- resched, ההקשר של התהליכים מתחלף לפני ש- resched נגמרת, אבל resched ממשיכה להתבצע ובסופה היא מחזירה את החישוב לתהליך ב'. סוף החישוב של resched מתבצע בהקשר של תהליך ב' בשלב מאוחר יותר, כשתהליך א' יחזור לביצוע, הוא ימשיך את הביצוע )ctxsw- resched בדיוק מהנקודה בה הוחלף ההקשר מקודם, כך שבסה"כ הוא מבצע את כל פקודות המכונה ב- resched וב- ctxsw 25

26 המחסנית בזמן קריאה ל- ctxsw תסריט: תהליך B התחלף בתהליך C,..., תהליך D התחלף בתהליך A, תהליך A מתחלף בתהליך B תהליך נכנס B (resched) &C -> pregs &B -> pregs כתובת חזרה bp flags si di B -> pregs תהליך יוצא A לפני קריאה (resched) &B -> pregs &A -> pregs 26

27 המחסנית בזמן קריאה ל- ctxsw תסריט: תהליך B התחלף בתהליך C,..., תהליך D התחלף בתהליך A, תהליך A מתחלף בתהליך B תהליך נכנס B (resched) &C -> pregs &B -> pregs אחרי קריאה A -> pregs תהליך יוצא A (resched) &B -> pregs &A -> pregs כתובת חזרה bp flags si di 27

28 resched & ctxsw השדה היחיד בטבלת התהליכים המשמש להחלפת תהליך הוא pregs )השומר את ערך SP מצביע על מחסנית( איך נשמר כל נתון בהקשר: אוגרים כלליים )DX,CX,BX,AX( נשמרים על ידי הקורא ל- resched אם הערכים שלהם חשובים לו Flags,BP,DI,SI נשמרים על ידי ctxsw על גבי המחסנית SS,ES,DS,CS לא משתנים ולא נשמרים )בפסיקה: ברמת הפסיקה(.resched- ל call נשמר ע"י פקודת IP SP ערכו לאחר הכנסת הקשר למחסנית נשמר בטבלת התהליכים ומשתחזר אוטומטית לערכו הקודם בהוצאה מהמחסנית משתני התהליך הנוכחי, שדות טבלת התהליכים ותור ready מעודכנים על ידי resched 28

29 disable / restore פונקציות משתמש ב- XINU מגנות על קטעי קוד קריטים באמצעות סמפורים ואמצעי סנכרון נוספים גם מערכת ההפעלה שהיא מריצה צריכה להגן על קטעי קוד קריטים מערכת הפעלה מכילה קטעי קוד הרגישים מאוד לפסיקות )חומרה או תוכנה( מערכת הפעלה מבצעת מניעת פסיקות באמצעות המקרו disable(ps) 29

30 eidi.asm disable(ps) 30

31 eidi.asm - restore(ps) מחזיר את הדגלים שנשמרו ב- ps restore(ps) #define restore(x) sys_restor (x) ; void sys_restor(ps) ; int ps; _sys_restor proc near pushbp mov bp,sp ; C calling convenion push [bp+4] popf ; restore flag word pop bp ret _sys_restor endp הדגלים השמורים במשתנה ps נדחפים על המחסנית ומיד מוצאים לתוך אוגר הדגלים restore מחזיר את המצב הנתון ב- ps. הוא אינו מאפשר בכל מקרה את הפסיקות!!! 31

32 שימוש ב- disable/restore ניתן לראת שקריאות מ"ה ב- XINU "עטופות" בצירוף int המשתנה הלוקלי מסוג הוא ו- ps disable(ps)/restore(ps) המקרו :enable() מדליק את דגל הפסיקות )קורא ל- sti (. במקרים קיצוניים בלבד נרצה להדליק את דגל הפסיקות ללא קשר לערכו האחרון בעת כיבויו. על פי רוב נשתמש ב- restore ;void sys_enabl)( _sys_enabl proc near sti ; enable interrupts ret _sys_enabl endp למשתמש אסור לקרא ל- disable/enable/restore 32

33 disable(ps)/restore(ps) מה קורה כשהתהליך מבצע קריאה מפורשת ל- בקוד ה"עטוף" ב- disable/restore? resched האם תתאפשר החלפת תהליכים? האם התהליך החדש ירוץ עם פסיקות מכובות? האם זה מותר? האם זה קורה בפועל? 33

34 disable(ps)/restore(ps) קריאות מפורשות ל- resched מותרות ואף נמצאות בקוד של מערכת ההפעלה disable אוסר טיפול בפסיקות ולא אוסר החלפת התהליכים. לכן, בעת ביצוע קוד מוגן ע"י disable/restore לא יתבצעו החלפות תהליכים "לא רצויות" )ולא צפויות( אלא רק כאלו שיזומות על ידי קריאה מפורשת ל- resched מצב הפסיקות )דגלים( נשמר במשתנה לוקלי על מחסנית התהליך הקורה ל- resched. בעת החלפת תהליכים נטען, בין השאר, רגיסטר הדגלים של התהליך החדש הנכנס לריצה בעת שהתהליך זה יבצע restore הוא ישחזר את מצבו מאז הקריאה האחרונה שלו ל- disable )מצב זה שמור על המחסנית הלוקלית שלו( שימו לב: ההשפעה של disable לוקלית על התהליך עצמו, וכשתהליך זה יחזור לריצה, ישוחזר מצבו בצורה מלאה 34

35 chprio.c chprio() 35

36 השעיית תהליכים ניתן להשעות את פעולתו של התהליך ולמנוע ממנו לההפך לתהליך הנוכחי חידוש פעולת התהליך יעשה ע"י בקשה מפורשת שתינתן ע"י תהליך אחר. תהליך מושעה מקבל מצב.PRSUSP תהליך יכול להשעות את עצמו )אבל לא לחדש את פעולת עצמו!( suspend מבצע ההשעיה בצורה שונה עבור תהליכים במצבי PRCURR ו- PRREDY תזכורת: תהליך חדש נוצר במצב PRSUSP 36

37 suspend.c 37

38 resume.c 38

39 resume.c ניתן לבצע resume )suspended( בעת הקריאה ל- ready ה- ready רק לתהליך מושעה יכנס התהליך לתור resched מופעל בכל אופן. אם התהליך הנכנס בעדיפות גבוהה יותר הוא יכנס לריצה. אחרת התהליך הנוכחי ימשיך לרוץ 39

40 ready.c 40

41 kill() pid מסיימת את פעולתו של תהליך kill(pid) בנוסף kill נקראת באופן אוטומטי בסיום קוד התהליך היא משחררת את: המחסנית של התהליך רשומת התהליך בטבלת התהליכים הוצאת רשומת התהליך מהתור בו היא נמצאת עדכונים ספציפיים למצב התהליך. למשל, אם תהליך מחכה לסמפור : הגדלת המונה ב- 1 resched במקרה של סיום התהליך הנוכחי ביצוע סיום ריצת XINU כשמסתיימים כל התהליכים כולל תהליכי מערכת ההפעלה 41

42 42

43 מהי מדיניות החלפת התהליכים אחרי שינוי? איך השינוי שעשינו משנה עדיפויות? int resched() { register struct pentry *optr; register struct pentry *nptr; דוגמה 1 int ready(pid) int pid; { register struct pentry* proc; } optr = &proctab[currpid]; if (optr->pstate == PRCURR) { if (sys_pcxget() == 0) return; // force context switch enqueue(currpid, rdytail); } } else if (sys_pcxget() == 0) { kprintf) (; panic) Reschedule impossible in this stage (; } nptr = &proctab[ (currpid == getfirst(readyhead)) ]; nptr->pstate = PRCURR; preempt = nptr->pprio; ctxsw(&optr->pregs, &nptr->pregs); if (isbad(pid)) return (SYSERR); pptr = &proctab[pid]; pptr->pstate = PRREADY; enqueue(pid, rdytail); 43

44 אמצעי תקשורת וסינכרון סמפור wait(s)/signal(s) שליחת הודעות send(pid, msg)/receive() 44

45 מימוש סמפורים מצב התהליך PRWAIT התהליך המחכה נמצא במצב PRWAIT המיוחד לסמפורים תור לכל סמפור לכל סמפור נשמר תור FIFO של התהליכים המחכים לו, כך ש- signal יוכל לשחרר את הראשון שבהם, ולהעבירו לתור ה- ready טבלת סמפורים semaph עם כניסות מסוג sentry כל כניסה מכילה מונה, מצביעים לתור )בטבלת q( ודגל הכניסה )SFREE/SUSED( ערך מזהה הסמפור sid הוא האינדקס של כניסתו בטבלת הסמפורים 45

46 מימוש סמפורים sem.h 46

47 wait.c קריאת מ"ה wait 47

48 קריאת מ"ה wait ביצוע wait לא מופרע באמצע ע"י מערכת ההפעלה. הגנה באמצעות.disable/restore אולם החלפת הקשר היא אפשרית גם באמצע עקב resched יזום לא ניתן לבצע wait על סמפור שלא נוצר, או שכבר שוחרר הכנסה לסוף תור הסמפור )כלומר )FIFO הקריאה ל- resched הכרחית 48

49 signal.c קריאת מ"ה signal 49

50 קריאת מ"ה signal ביצוע signal לא מופרע באמצע ע"י מערכת ההפעלה. הגנה באמצעות.disable/restore אולם החלפת הקשר היא אפשרית גם באמצע עקב resched יזום לא ניתן לבצע שוחרר signal ההוצאה מראש תור הסמפורים על סמפור שלא נוצר, או שכבר )FIFO( האם הקריאה ל- resched הכרחית כפי שהיתה הכרחית ב- wait? 50

51 screate.c קריאת מ"ה screate לא ניתן ליצור סמפור עם ערך התחלתי שלילי. מה המשמעות של ערך שלילי? 51

52 קריאת מ"ה screate ביצוע signal לא מופרע באמצע ע"י מערכת ההפעלה. הגנה באמצעות.disable/restore אולם החלפת הקשר היא אפשרית גם באמצע עקב resched יזום לא ניתן לבצע שוחרר signal ההוצאה מראש תור הסמפורים על סמפור שלא נוצר, או שכבר )FIFO( האם הקריאה ל- resched הכרחית כפי שהיתה הכרחית ב- wait? 52

53 המשך קריאת מ"ה screate בעת אתחול המערכת הוצב קבוע SFREE לכל רשומות הסמפורים 53

54 קריאת מ"ה sdelete 54

55 קריאת מ"ה sdelete אם, בעת מחיקת הסמפור, את כל התהליכים קיימים תהליכים המחכים לו, משחררים בסוף לולאת while מבצעים.resched האם מותר גם בתוך הלולאה? לשים לב: מחיקת סמפור כאשר יש תהליכים המחקים בתור היא פעולה מסוכנת ולא טבעית )הרי יש סיבה שבגללה הם מחכים לסמפור...( ישנן מערכות הפעלה בהן לא ניתן לשחרר סמפור שתורו לא ריק 55

56 signaln.c ready() מרכזת את כל הטיפול בתור התהליכים המוכנים 56

57 sreset.c מה ההבדל בין קריאה ל- sreset לבין שתי קריאות רצופות ל- ו- screate? sdelete 57

58 הודעות ב- XINU XINU מוגבלת מאוד באמצעי העברת ההודעות שלה. סוגי העברה: משלוח לא חוסם send( קבלה חוסמת ולא חוסמת שליחת ההודעות למיניהם( לתהליך מסויים )receiveclr, receive( 58

59 הודעות ב- XINU באמצעות העברת ההודעות ב- XINU ניתן: להעביר מסרים לתאם בין תהליכים )בנוסף לסמפורים( מגבלות: הודעת int בלבד כשמגיעים מספר מסרים, רק הראשון מתקבל והשאר הולכים לאיבוד 59

60 העברת הודעות מבנה נתונים מצב התהליך,PRRECV תהליך מחכה נמצא במצב PRRECV )מיוחד להמתנה להודעות( שדות pmsg ו- phasmsg בטבלת התהליכים ההודעה הנשלחת לתהליך מוכנסת לשדה pmsg ברשומת התהליך השדה phasmsg מסמן אם יש הודעה ממתינה 60

61 send.c קריאת מ"ה send 61

62 send.c קריאת מערכת הפעלה send מתבצעת בצורה רצופה מבלי שתופרע ע"י מערכת ההפעלה אולם, החלפת ההקשר יכולה לקרות ע"י resched יזום בדיקות תקינות כוללות בדיקה שאין כבר הודעה המחכה עבור התהליך המקבל אם התהליך מחכה מעירים אותו ומבצעים resched מערכות הפעלה - תרגול 2 62

63 receive.c קריאת מ"ה receive 63

64 receive.c קריאת מ"ה receive receive מתבצעת בצורה רצופה מבלי שתופרע ע"י מערכת ההפעלה אולם, החלפת ההקשר יכולה לקרות ע"י resched יזום אם אין הודעה התהליך עובר למצב PRRECV ויוצא מהמעבד אחרי resched האם הוא נמצא בתור כלשהו? איך יחזור לפעולה? מערכות הפעלה - תרגול 2 64

65 receiveclr.c קריאת מ"ה receiveclr 65

UnderWarrior Project

UnderWarrior Project גירסה 1.00 26.3.2003 - מערכת ההפעלה XINU מסמךזההורדמהאתרhttp://underwar.livedns.co.il. איןלהפיץמסמךזהבמדיהכלשהי, ללאאישורמפורשמאתהמחבר. מחברהמסמךאיננואחראילכלנזק, ישיראועקיף, שיגרםעקבהשימושבמידעהמופיעבמסמך,